home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / Filezilla Server / FileZilla_Server-0_9_41.exe / source / Accounts.cpp next >
C/C++ Source or Header  |  2011-11-06  |  12KB  |  583 lines
  1. #include "stdafx.h"
  2. #include "accounts.h"
  3. #include "iputils.h"
  4.  
  5. t_directory::t_directory()
  6. {
  7.     bAutoCreate = FALSE;
  8. }
  9.  
  10. t_group::t_group()
  11. {
  12.     pOwner = NULL;
  13.  
  14.     for (int i = 0; i < 2; i++)
  15.     {
  16.         nSpeedLimitType[i] = 0;
  17.         nSpeedLimit[i] = 10;
  18.         nBypassServerSpeedLimit[i] = 0;
  19.     }
  20.     nEnabled = 1;
  21.     forceSsl = 0;
  22. }
  23.  
  24. t_group& t_group::operator=(const t_group &a)
  25. {
  26.     group = a.group;
  27.     nBypassUserLimit = a.nBypassUserLimit;
  28.     nUserLimit = a.nUserLimit;
  29.     nIpLimit = a.nIpLimit;
  30.     permissions = a.permissions;
  31.     nEnabled = a.nEnabled;
  32.     disallowedIPs = a.disallowedIPs;
  33.     allowedIPs = a.allowedIPs;
  34.     comment = a.comment;
  35.     forceSsl = a.forceSsl;
  36.  
  37.     for (int i = 0; i < 2; i++)
  38.     {
  39.         nBypassServerSpeedLimit[i] = a.nBypassServerSpeedLimit[i];
  40.         nSpeedLimit[i] = a.nSpeedLimit[i];
  41.         nSpeedLimitType[i] = a.nSpeedLimitType[i];
  42.         SpeedLimits[i] = a.SpeedLimits[i];
  43.     }
  44.  
  45.     return *this;
  46. }
  47.  
  48. bool t_group::BypassUserLimit() const
  49. {
  50.     if (!nBypassUserLimit)
  51.         return false;
  52.     if (nBypassUserLimit == 2 && pOwner)
  53.         return pOwner->BypassUserLimit();
  54.     return true;
  55. }
  56.  
  57. int t_group::GetIpLimit() const
  58. {
  59.     if (nIpLimit)
  60.         return nIpLimit;
  61.     if (pOwner)
  62.         return pOwner->GetIpLimit();
  63.     return 0;
  64. }
  65.  
  66. int t_group::GetUserLimit() const
  67. {
  68.     if (nUserLimit)
  69.         return nUserLimit;
  70.     if (pOwner)
  71.         return pOwner->GetUserLimit();
  72.     return 0;
  73. }
  74.  
  75. t_user::t_user()
  76. {
  77. }
  78.  
  79. t_user& t_user::operator=(const t_user &a)
  80. {
  81.     group = a.group;
  82.     pOwner = a.pOwner;
  83.     user=a.user;
  84.     password=a.password;
  85.     nBypassUserLimit = a.nBypassUserLimit;
  86.     nUserLimit = a.nUserLimit;
  87.     nIpLimit = a.nIpLimit;
  88.     permissions = a.permissions;
  89.     nEnabled = a.nEnabled;
  90.     disallowedIPs = a.disallowedIPs;
  91.     allowedIPs = a.allowedIPs;
  92.     comment = a.comment;
  93.     forceSsl = a.forceSsl;
  94.  
  95.     for (int i = 0; i < 2; i++)
  96.     {
  97.         nBypassServerSpeedLimit[i] = a.nBypassServerSpeedLimit[i];
  98.         nSpeedLimit[i] = a.nSpeedLimit[i];
  99.         nSpeedLimitType[i] = a.nSpeedLimitType[i];
  100.         SpeedLimits[i] = a.SpeedLimits[i];
  101.     }
  102.  
  103.     return *this;
  104. }
  105.  
  106. unsigned char * t_group::ParseBuffer(unsigned char *pBuffer, int length)
  107. {
  108.     unsigned char *p = pBuffer;
  109.     unsigned char *endMarker = pBuffer + length;
  110.  
  111.     if (!ParseString(endMarker, p, group))
  112.         return 0;
  113.  
  114.     if ((endMarker - p) < 11)
  115.         return NULL;
  116.  
  117.     memcpy(&nIpLimit, p, 4);
  118.     p += 4;
  119.     memcpy(&nUserLimit, p, 4);
  120.     p += 4;
  121.  
  122.     int options = *p++;
  123.  
  124.     nBypassUserLimit    = options & 0x03;
  125.     nEnabled            = (options >> 2) & 0x03;
  126.  
  127.     // Parse IP filter rules.
  128.     int numDisallowedIPs = (int(*p) << 8) + p[1];
  129.     p += 2;
  130.     while (numDisallowedIPs--)
  131.     {
  132.         CStdString ip;
  133.         if (!ParseString(endMarker, p, ip))
  134.             return 0;
  135.  
  136.         if (IsValidAddressFilter(ip) || ip == _T("*"))
  137.             disallowedIPs.push_back(ip);
  138.     }
  139.  
  140.     if ((endMarker - p) < 2)
  141.         return NULL;
  142.  
  143.     int numAllowedIPs = (int(*p) << 8) + p[1];
  144.     p += 2;
  145.     while (numAllowedIPs--)
  146.     {
  147.         CStdString ip;
  148.         if (!ParseString(endMarker, p, ip))
  149.             return 0;
  150.  
  151.         if (IsValidAddressFilter(ip) || ip == _T("*"))
  152.             allowedIPs.push_back(ip);
  153.     }
  154.  
  155.     if ((endMarker - p) < 2)
  156.         return NULL;
  157.  
  158.     int dircount = (int(*p) << 8) + p[1];
  159.     p += 2;
  160.  
  161.     BOOL bGotHome = FALSE;
  162.  
  163.     for (int j = 0; j < dircount; j++)
  164.     {
  165.         t_directory dir;
  166.  
  167.         CStdString str;
  168.         if (!ParseString(endMarker, p, str))
  169.             return 0;
  170.  
  171.         str.TrimRight(_T("\\"));
  172.         if (str == _T(""))
  173.             return 0;
  174.  
  175.         dir.dir = str;
  176.  
  177.         // Get directory aliases.
  178.         if ((endMarker - p) < 2)
  179.             return NULL;
  180.  
  181.         int aliascount = (int(*p) << 8) + p[1];
  182.         p += 2;
  183.  
  184.         for (int i = 0; i < aliascount; i++)
  185.         {
  186.             CStdString alias;
  187.             if (!ParseString(endMarker, p, alias))
  188.                 return 0;
  189.  
  190.             alias.TrimRight(_T("\\"));
  191.  
  192.             if (alias == _T(""))
  193.                 return 0;
  194.  
  195.             dir.aliases.push_back(alias);
  196.         }
  197.  
  198.         if ((endMarker - p) < 2)
  199.             return NULL;
  200.  
  201.         int rights = (int(*p) << 8) + p[1];
  202.         p += 2;
  203.  
  204.         dir.bDirCreate    = rights & 0x0001 ? 1:0;
  205.         dir.bDirDelete    = rights & 0x0002 ? 1:0;
  206.         dir.bDirList    = rights & 0x0004 ? 1:0;
  207.         dir.bDirSubdirs    = rights & 0x0008 ? 1:0;
  208.         dir.bFileAppend    = rights & 0x0010 ? 1:0;
  209.         dir.bFileDelete    = rights & 0x0020 ? 1:0;
  210.         dir.bFileRead    = rights & 0x0040 ? 1:0;
  211.         dir.bFileWrite    = rights & 0x0080 ? 1:0;
  212.         dir.bIsHome        = rights & 0x0100 ? 1:0;
  213.         dir.bAutoCreate    = rights & 0x0200 ? 1:0;
  214.  
  215.         // Avoid multiple home directories.
  216.         if (dir.bIsHome)
  217.             if (!bGotHome)
  218.                 bGotHome = TRUE;
  219.             else
  220.                 dir.bIsHome = FALSE;
  221.  
  222.         permissions.push_back(dir);
  223.     }
  224.  
  225.     for (int i = 0; i < 2; i++)
  226.     {
  227.         if ((endMarker - p) < 5)
  228.             return NULL;
  229.  
  230.         nSpeedLimitType[i] = *p & 3;
  231.         nBypassServerSpeedLimit[i] = (*p++ >> 2) & 3;
  232.  
  233.         nSpeedLimit[i] = int(*p++) << 8;
  234.         nSpeedLimit[i] |= *p++;
  235.     
  236.         if (!nSpeedLimit[i])
  237.             nSpeedLimit[i] = 10;
  238.  
  239.         int num = (int(*p) << 8) + p[1];
  240.         p += 2;
  241.         while (num--)
  242.         {
  243.             CSpeedLimit sl;
  244.             p = sl.ParseBuffer(p, length-(int)(p-pBuffer));
  245.             if (!p)
  246.                 return NULL;
  247.             SpeedLimits[i].push_back(sl);
  248.         }
  249.     }
  250.  
  251.     if (!ParseString(endMarker, p, comment))
  252.         return 0;
  253.  
  254.     if (p >= endMarker)
  255.         return 0;
  256.  
  257.     forceSsl = *p++;
  258.  
  259.     return p;
  260. }
  261.  
  262. int t_group::GetRequiredStringBufferLen(const CStdString& str) const
  263. {
  264.     char* utf8 = ConvToNetwork(str);
  265.  
  266.     if (!utf8)
  267.         return 2;
  268.  
  269.     int len = strlen(utf8);
  270.  
  271.     delete [] utf8;
  272.  
  273.     return len + 2;
  274. }
  275.  
  276. void t_group::FillString(char *& p, const CStdString& str) const
  277. {
  278.     char* utf8 = ConvToNetwork(str);
  279.  
  280.     if (!utf8)
  281.     {
  282.         *p++ = 0;
  283.         *p++ = 0;
  284.         return;
  285.     }
  286.  
  287.     int len = strlen(utf8);
  288.     *p++ = (char)(len >> 8);
  289.     *p++ = (char)(len & 0xff);
  290.  
  291.     memcpy(p, utf8, len);
  292.     p += len;
  293.  
  294.     delete [] utf8;
  295. }
  296.  
  297. char * t_group::FillBuffer(char *p) const
  298. {
  299.     FillString(p, group);
  300.     
  301.     memcpy(p, &nIpLimit, 4);
  302.     p += 4;
  303.     memcpy(p, &nUserLimit, 4);
  304.     p += 4;
  305.  
  306.     int options = nBypassUserLimit & 3;
  307.     options |= (nEnabled & 3) << 2;
  308.  
  309.     *p++ = options & 0xff;
  310.  
  311.     std::list<CStdString>::const_iterator ipLimitIter;
  312.  
  313.     *p++ = (char)(disallowedIPs.size() >> 8);
  314.     *p++ = (char)(disallowedIPs.size() & 0xff);
  315.     for (ipLimitIter = disallowedIPs.begin(); ipLimitIter != disallowedIPs.end(); ipLimitIter++)
  316.         FillString(p, *ipLimitIter);
  317.  
  318.     *p++ = (char)(allowedIPs.size() >> 8);
  319.     *p++ = (char)(allowedIPs.size() & 0xff);
  320.     for (ipLimitIter = allowedIPs.begin(); ipLimitIter != allowedIPs.end(); ipLimitIter++)
  321.         FillString(p, *ipLimitIter);
  322.  
  323.     *p++ = (char)(permissions.size() >> 8);
  324.     *p++ = (char)(permissions.size() & 0xff);
  325.     for (std::vector<t_directory>::const_iterator permissioniter = permissions.begin(); permissioniter!=permissions.end(); permissioniter++)
  326.     {
  327.         FillString(p, permissioniter->dir);
  328.  
  329.         *p++ = (char)(permissioniter->aliases.size() >> 8);
  330.         *p++ = (char)(permissioniter->aliases.size() & 0xff);
  331.         for (std::list<CStdString>::const_iterator aliasiter = permissioniter->aliases.begin(); aliasiter != permissioniter->aliases.end(); aliasiter++)
  332.             FillString(p, *aliasiter);
  333.  
  334.         int rights = 0;
  335.         rights |= permissioniter->bDirCreate    ? 0x0001:0;
  336.         rights |= permissioniter->bDirDelete    ? 0x0002:0;
  337.         rights |= permissioniter->bDirList        ? 0x0004:0;
  338.         rights |= permissioniter->bDirSubdirs    ? 0x0008:0;
  339.         rights |= permissioniter->bFileAppend    ? 0x0010:0;
  340.         rights |= permissioniter->bFileDelete    ? 0x0020:0;
  341.         rights |= permissioniter->bFileRead        ? 0x0040:0;
  342.         rights |= permissioniter->bFileWrite    ? 0x0080:0;
  343.         rights |= permissioniter->bIsHome        ? 0x0100:0;
  344.         rights |= permissioniter->bAutoCreate    ? 0x0200:0;
  345.         *p++ = (char)(rights >> 8);
  346.         *p++ = (char)(rights & 0xff);
  347.     }
  348.  
  349.     for (int i = 0; i < 2; i++)
  350.     {
  351.         *p++ = (char)((nSpeedLimitType[i] & 3) + ((nBypassServerSpeedLimit[i] & 3) << 2));
  352.         *p++ = (char)(nSpeedLimit[i] >> 8);
  353.         *p++ = (char)(nSpeedLimit[i] & 0xff);
  354.  
  355.         SPEEDLIMITSLIST::const_iterator iter;
  356.  
  357.         *p++ = (char)(SpeedLimits[i].size() >> 8);
  358.         *p++ = (char)(SpeedLimits[i].size() & 0xff);
  359.         for (iter = SpeedLimits[i].begin(); (iter != SpeedLimits[i].end()) && p; iter++)
  360.             p = iter->FillBuffer(p);
  361.         if (!p)
  362.             return NULL;
  363.     }
  364.  
  365.     FillString(p, comment);
  366.  
  367.     *p++ = (char)forceSsl;
  368.  
  369.     return p;
  370. }
  371.  
  372. int t_group::GetRequiredBufferLen() const
  373. {
  374.     int len = 9;
  375.     len += GetRequiredStringBufferLen(group);
  376.  
  377.     len += 4;
  378.     std::list<CStdString>::const_iterator ipLimitIter;
  379.     for (ipLimitIter = disallowedIPs.begin(); ipLimitIter != disallowedIPs.end(); ipLimitIter++)
  380.         len += GetRequiredStringBufferLen(*ipLimitIter);
  381.     for (ipLimitIter = allowedIPs.begin(); ipLimitIter != allowedIPs.end(); ipLimitIter++)
  382.         len += GetRequiredStringBufferLen(*ipLimitIter);
  383.  
  384.     len += 2;
  385.     for (std::vector<t_directory>::const_iterator permissioniter = permissions.begin(); permissioniter!=permissions.end(); permissioniter++)
  386.     {
  387.         t_directory directory = *permissioniter;
  388.         len += 2;
  389.  
  390.         len += GetRequiredStringBufferLen(directory.dir);
  391.  
  392.         len += 2;
  393.         for (std::list<CStdString>::const_iterator aliasiter = permissioniter->aliases.begin(); aliasiter != permissioniter->aliases.end(); aliasiter++)
  394.             len += GetRequiredStringBufferLen(*aliasiter);
  395.     }
  396.  
  397.     // Speed limits.
  398.     len += 6; // Basic limits.
  399.     len += 4; // Number of rules.
  400.     for (int i = 0; i < 2; i++)
  401.     {
  402.         SPEEDLIMITSLIST::const_iterator iter;
  403.         for (iter = SpeedLimits[i].begin(); iter != SpeedLimits[i].end(); iter++)
  404.             len += iter->GetRequiredBufferLen();
  405.     }
  406.  
  407.     len += GetRequiredStringBufferLen(comment);
  408.  
  409.     len++; //forceSsl
  410.  
  411.     return len;
  412. }
  413.  
  414. int t_group::GetCurrentSpeedLimit(sltype type) const
  415. {
  416.     switch (nSpeedLimitType[type])
  417.     {
  418.     case 0:
  419.         if (pOwner)
  420.             return pOwner->GetCurrentSpeedLimit(type);
  421.         else
  422.             return 0;
  423.     case 1:
  424.         return 0;
  425.     case 2:
  426.         return nSpeedLimit[type];
  427.     case 3:
  428.         {
  429.             SYSTEMTIME st;
  430.             GetLocalTime(&st);
  431.             for (SPEEDLIMITSLIST::const_iterator iter = SpeedLimits[type].begin(); iter != SpeedLimits[type].end(); iter++)
  432.                 if (iter->IsItActive(st))
  433.                     return iter->m_Speed;
  434.         }
  435.         if (pOwner)
  436.             return pOwner->GetCurrentSpeedLimit(type);
  437.         else
  438.             return 0;
  439.     }
  440.     return 0;
  441. }
  442.  
  443. bool t_group::BypassServerSpeedLimit(sltype type) const
  444. {
  445.     if (nBypassServerSpeedLimit[type] == 1)
  446.         return true;
  447.     else if (!nBypassServerSpeedLimit[type])
  448.         return false;
  449.     else if (pOwner)
  450.         return pOwner->BypassServerSpeedLimit(type);
  451.     else
  452.         return false;
  453. }
  454.  
  455. bool t_group::IsEnabled() const
  456. {
  457.     switch (nEnabled)
  458.     {
  459.     default:
  460.     case 0:
  461.         return false;
  462.     case 1:
  463.         return true;
  464.     case 2:
  465.         if (!pOwner)
  466.             return false;
  467.  
  468.         return pOwner->IsEnabled();
  469.     }
  470. }
  471.  
  472. bool t_group::AccessAllowed(const CStdString& ip) const
  473. {
  474.     bool disallowed = false;
  475.  
  476.     std::list<CStdString>::const_iterator iter;
  477.     for (iter = disallowedIPs.begin(); iter != disallowedIPs.end(); iter++)
  478.     {
  479.         if (disallowed = MatchesFilter(*iter, ip))
  480.             break;
  481.     }
  482.  
  483.     if (!disallowed)
  484.     {
  485.         if (!pOwner)
  486.             return true;
  487.  
  488.         if (pOwner->AccessAllowed(ip))
  489.             return true;
  490.     }
  491.  
  492.     for (iter = allowedIPs.begin(); iter != allowedIPs.end(); iter++)
  493.     {
  494.         if (MatchesFilter(*iter, ip))
  495.             return true;
  496.     }
  497.  
  498.     if (pOwner && !disallowed)
  499.         return pOwner->AccessAllowed(ip);
  500.  
  501.     return false;
  502. }
  503.  
  504. unsigned char * t_user::ParseBuffer(unsigned char *pBuffer, int length)
  505. {
  506.     unsigned char *p = pBuffer;
  507.     unsigned char *endMarker = pBuffer + length;
  508.  
  509.     p = t_group::ParseBuffer(p, length);
  510.     if (!p)
  511.         return NULL;
  512.  
  513.     if (!ParseString(endMarker, p, user))
  514.         return 0;
  515.  
  516.     if (!ParseString(endMarker, p, password))
  517.         return 0;
  518.  
  519.     return p;
  520. }
  521.  
  522. char * t_user::FillBuffer(char *p) const
  523. {
  524.     p = t_group::FillBuffer(p);
  525.     if (!p)
  526.         return NULL;
  527.  
  528.     FillString(p, user);
  529.     FillString(p, password);
  530.  
  531.     return p;
  532. }
  533.  
  534. int t_user::GetRequiredBufferLen() const
  535. {
  536.     int len = t_group::GetRequiredBufferLen();
  537.     len += GetRequiredStringBufferLen(user);
  538.     len += GetRequiredStringBufferLen(password);
  539.     return len;
  540. }
  541.  
  542. bool t_group::ParseString(const unsigned char* endMarker, unsigned char *&p, CStdString &string)
  543. {
  544.     if ((endMarker - p) < 2)
  545.         return false;
  546.  
  547.     int len = *p * 256 + p[1];
  548.     p += 2;
  549.  
  550.     if ((endMarker - p) < len)
  551.         return false;
  552.     char* tmp = new char[len + 1];
  553.     tmp[len] = 0;
  554.     memcpy(tmp, p, len);
  555.     CStdStringW str = ConvFromNetwork((const char*)tmp);
  556.     delete [] tmp;
  557.     p += len;
  558. #ifdef _UNICODE
  559.     string = str;
  560. #else
  561.     string = ConvToLocal(str);
  562. #endif
  563.     
  564.     return true;
  565. }
  566.  
  567. bool t_group::ForceSsl() const
  568. {
  569.     switch (forceSsl)
  570.     {
  571.     default:
  572.     case 0:
  573.         return false;
  574.     case 1:
  575.         return true;
  576.     case 2:
  577.         if (!pOwner)
  578.             return false;
  579.  
  580.         return pOwner->ForceSsl();
  581.     }
  582. }
  583.